#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "StrUtil.hpp"
#include <vector>

/*!
 * \brief 字符串工具类测试套件
 * 
 * \details 测试StrUtil类的各种字符串操作功能，包括：
 *          - 字符串修剪功能
 *          - 字符串分割功能  
 *          - 大小写转换功能
 *          - 字符串匹配功能
 *          - 路径处理功能
 *          - 格式化功能
 */
class StringUtilsTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 测试前的设置
        test_string_with_spaces = "  hello world  ";
        test_string_empty = "";
        test_string_only_spaces = "   ";
        test_string_mixed = "Hello World Test String";
        test_string_csv = "apple,banana,cherry,date";
        test_string_path = "/path/to/file.txt";
    }
    
    void TearDown() override {
        // 测试后的清理
    }

    // 测试数据
    std::string test_string_with_spaces;
    std::string test_string_empty;
    std::string test_string_only_spaces;
    std::string test_string_mixed;
    std::string test_string_csv;
    std::string test_string_path;
};

// ========== 字符串修剪测试 ==========

TEST_F(StringUtilsTest, TestTrimBothSides) {
    std::string test_str = test_string_with_spaces;
    StrUtil::trim(test_str);
    EXPECT_EQ(test_str, "hello world");
}

TEST_F(StringUtilsTest, TestTrimLeftOnly) {
    std::string test_str = test_string_with_spaces;
    StrUtil::trim(test_str, " \t\r", true, false);
    EXPECT_EQ(test_str, "hello world  ");
}

TEST_F(StringUtilsTest, TestTrimRightOnly) {
    std::string test_str = test_string_with_spaces;
    StrUtil::trim(test_str, " \t\r", false, true);
    EXPECT_EQ(test_str, "  hello world");
}

TEST_F(StringUtilsTest, TestTrimEmptyString) {
    std::string test_str = test_string_empty;
    StrUtil::trim(test_str);
    EXPECT_EQ(test_str, "");
}

TEST_F(StringUtilsTest, TestTrimOnlySpaces) {
    std::string test_str = test_string_only_spaces;
    StrUtil::trim(test_str);
    EXPECT_EQ(test_str, "");
}

TEST_F(StringUtilsTest, TestTrimConstString) {
    std::string result = StrUtil::trim("  test string  ");
    EXPECT_EQ(result, "test string");
}

TEST_F(StringUtilsTest, TestTrimAllSpaces) {
    std::string test_str = "hello world test";
    StrUtil::trimAllSpace(test_str);
    EXPECT_EQ(test_str, "helloworldtest");
}

TEST_F(StringUtilsTest, TestTrimAllSpecificChar) {
    std::string test_str = "a-b-c-d-e";
    StrUtil::trimAll(test_str, '-');
    EXPECT_EQ(test_str, "abcde");
}

// ========== 字符串分割测试 ==========

TEST_F(StringUtilsTest, TestSplitBasic) {
    StringVector result = StrUtil::split(test_string_csv, ",");
    EXPECT_EQ(result.size(), 4);
    EXPECT_EQ(result[0], "apple");
    EXPECT_EQ(result[1], "banana");
    EXPECT_EQ(result[2], "cherry");
    EXPECT_EQ(result[3], "date");
}

TEST_F(StringUtilsTest, TestSplitWithMaxSplits) {
    StringVector result = StrUtil::split(test_string_csv, ",", 2);
    EXPECT_EQ(result.size(), 3);
    EXPECT_EQ(result[0], "apple");
    EXPECT_EQ(result[1], "banana");
    EXPECT_EQ(result[2], "cherry,date");
}

TEST_F(StringUtilsTest, TestSplitEmptyString) {
    StringVector result = StrUtil::split("", ",");
    EXPECT_EQ(result.size(), 1);
    EXPECT_EQ(result[0], "");
}

TEST_F(StringUtilsTest, TestSplitNoDelimiter) {
    StringVector result = StrUtil::split("hello", ",");
    EXPECT_EQ(result.size(), 1);
    EXPECT_EQ(result[0], "hello");
}

TEST_F(StringUtilsTest, TestSplitMultipleDelimiters) {
    StringVector result = StrUtil::split("a,b;c:d", ",;:");
    EXPECT_EQ(result.size(), 4);
    EXPECT_EQ(result[0], "a");
    EXPECT_EQ(result[1], "b");
    EXPECT_EQ(result[2], "c");
    EXPECT_EQ(result[3], "d");
}

TEST_F(StringUtilsTest, TestSplitConsecutiveDelimiters) {
    StringVector result = StrUtil::split("a,,b", ",");
    EXPECT_EQ(result.size(), 3);
    EXPECT_EQ(result[0], "a");
    EXPECT_EQ(result[1], "");
    EXPECT_EQ(result[2], "b");
}

// ========== 大小写转换测试 ==========

TEST_F(StringUtilsTest, TestToLowerCase) {
    std::string test_str = test_string_mixed;
    StrUtil::toLowerCase(test_str);
    EXPECT_EQ(test_str, "hello world test string");
}

TEST_F(StringUtilsTest, TestToUpperCase) {
    std::string test_str = test_string_mixed;
    StrUtil::toUpperCase(test_str);
    EXPECT_EQ(test_str, "HELLO WORLD TEST STRING");
}

TEST_F(StringUtilsTest, TestMakeLowerCase) {
    std::string result = StrUtil::makeLowerCase("HELLO WORLD");
    EXPECT_EQ(result, "hello world");
}

TEST_F(StringUtilsTest, TestMakeUpperCase) {
    std::string result = StrUtil::makeUpperCase("hello world");
    EXPECT_EQ(result, "HELLO WORLD");
}

// ========== 数值转换测试 ==========

TEST_F(StringUtilsTest, TestToFloat) {
    float result = StrUtil::toFloat("3.14159");
    EXPECT_FLOAT_EQ(result, 3.14159f);
}

TEST_F(StringUtilsTest, TestToDouble) {
    double result = StrUtil::toDouble("3.141592653589793");
    EXPECT_DOUBLE_EQ(result, 3.141592653589793);
}

TEST_F(StringUtilsTest, TestToFloatInvalid) {
    float result = StrUtil::toFloat("invalid");
    EXPECT_EQ(result, 0.0f);
}

// ========== 字符串匹配测试 ==========

TEST_F(StringUtilsTest, TestStartsWith) {
    EXPECT_TRUE(StrUtil::startsWith("hello world", "hello"));
    EXPECT_FALSE(StrUtil::startsWith("hello world", "world"));
    EXPECT_TRUE(StrUtil::startsWith("HELLO WORLD", "hello", true));  // 忽略大小写
    EXPECT_FALSE(StrUtil::startsWith("HELLO WORLD", "hello", false)); // 区分大小写
}

TEST_F(StringUtilsTest, TestEndsWith) {
    EXPECT_TRUE(StrUtil::endsWith("hello world", "world"));
    EXPECT_FALSE(StrUtil::endsWith("hello world", "hello"));
    EXPECT_TRUE(StrUtil::endsWith("HELLO WORLD", "world", true));  // 忽略大小写
    EXPECT_FALSE(StrUtil::endsWith("HELLO WORLD", "world", false)); // 区分大小写
}

TEST_F(StringUtilsTest, TestMatch) {
    EXPECT_TRUE(StrUtil::match("hello", "hello"));
    EXPECT_TRUE(StrUtil::match("hello", "h*o"));
    EXPECT_TRUE(StrUtil::match("hello", "he??o"));
    EXPECT_FALSE(StrUtil::match("hello", "world"));
}

// ========== 路径处理测试 ==========

TEST_F(StringUtilsTest, TestStandardisePath) {
    std::string path1 = StrUtil::standardisePath("/path/to/file.txt", false);
    EXPECT_EQ(path1, "/path/to/file.txt");
    
    std::string path2 = StrUtil::standardisePath("/path/to/dir", true);
    EXPECT_EQ(path2, "/path/to/dir/");
}

TEST_F(StringUtilsTest, TestSplitFilename) {
    std::string basename, path;
    StrUtil::splitFilename("/path/to/file.txt", basename, path);
    EXPECT_EQ(basename, "file.txt");
    EXPECT_EQ(path, "/path/to/");
}

// ========== 查找功能测试 ==========

TEST_F(StringUtilsTest, TestFindFirst) {
    std::size_t pos = StrUtil::findFirst("hello world", 'o');
    EXPECT_EQ(pos, 4);
    
    std::size_t not_found = StrUtil::findFirst("hello", 'x');
    EXPECT_EQ(not_found, std::string::npos);
}

// ========== 格式化测试 ==========

TEST_F(StringUtilsTest, TestPrintf) {
    std::string result = StrUtil::printf("Hello %s, number is %d", "World", 42);
    EXPECT_EQ(result, "Hello World, number is 42");
}

TEST_F(StringUtilsTest, TestPrintfEmpty) {
    std::string result = StrUtil::printf("");
    EXPECT_EQ(result, "");
}

// ========== 字符串操作测试 ==========

TEST_F(StringUtilsTest, TestLeft) {
    std::string result = StrUtil::left("hello world", 5);
    EXPECT_EQ(result, "hello");
}

TEST_F(StringUtilsTest, TestRight) {
    std::string result = StrUtil::right("hello world", 5);
    EXPECT_EQ(result, "world");
}

TEST_F(StringUtilsTest, TestCharCount) {
    std::size_t count = StrUtil::charCount("hello world", 'l');
    EXPECT_EQ(count, 3);
}

TEST_F(StringUtilsTest, TestReplace) {
    std::string test_str = "hello world hello";
    StrUtil::replace(test_str, "hello", "hi");
    EXPECT_EQ(test_str, "hi world hi");
}

TEST_F(StringUtilsTest, TestExtend) {
    std::string result = StrUtil::extend("test", 10);
    EXPECT_EQ(result.length(), 10);
    EXPECT_TRUE(result.find("test") == 0);
}

// ========== 边界条件测试 ==========

TEST_F(StringUtilsTest, TestEmptyStringOperations) {
    std::string empty = "";
    
    // 测试空字符串的各种操作
    StrUtil::trim(empty);
    EXPECT_EQ(empty, "");
    
    StringVector split_result = StrUtil::split(empty, ",");
    EXPECT_EQ(split_result.size(), 1);
    EXPECT_EQ(split_result[0], "");
    
    StrUtil::toLowerCase(empty);
    EXPECT_EQ(empty, "");
    
    StrUtil::toUpperCase(empty);
    EXPECT_EQ(empty, "");
}

TEST_F(StringUtilsTest, TestNullAndEmptyStrings) {
    // 测试空字符串的开始和结束匹配
    // 根据WonderTrader的实际实现，空模式返回false（这是设计决策）
    EXPECT_FALSE(StrUtil::startsWith("", ""));
    EXPECT_FALSE(StrUtil::endsWith("", ""));
    
    // 测试空模式匹配
    // 空模式不匹配非空字符串，但空字符串匹配空模式
    EXPECT_FALSE(StrUtil::match("hello", ""));
    EXPECT_TRUE(StrUtil::match("", ""));
}

// ========== 性能相关测试 ==========

TEST_F(StringUtilsTest, TestLargeStringOperations) {
    // 创建一个大字符串进行测试
    std::string large_string(10000, 'a');
    large_string += "target";
    large_string += std::string(10000, 'b');
    
    // 测试查找操作
    EXPECT_TRUE(large_string.find("target") != std::string::npos);
    
    // 测试修剪操作（在两端添加空格）
    std::string trimmed = "   " + large_string + "   ";
    StrUtil::trim(trimmed);
    EXPECT_EQ(trimmed, large_string);
} 